www.gusucode.com > DB-Libray 操作SQLServer编程的VC++ 一例-源码程序 > DB-Libray 操作SQLServer编程的VC++ 一例-源码程序\code\PhManage\DBLibrary.cpp

    //Download by http://www.NewXing.com
// DBLibraty.cpp: implementation of the DBLibraty class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "DBLibrary.h"
#include "time.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
DBLibrary::DBLibrary()
{
	init();
	dbproc=NULL;
}
DBLibrary::DBLibrary(CDBSession &pDBSession)
{
	init();
	/*
	dbproc=pDBSession->dbproc;
	login=pDBSession->login;
	strcpy(app_name,pDBSession.app_name);
	strcpy(ErrLogFile,pDBSession.ErrLogFile);
	strcpy(LogFileName,pDBSession.LogFileName);*/
	for(int i=0;i<MAXPROCS;i++)
	{
		if (dbproc_status[i]==1)
		{
			this->dbproc=pDBSession.dbproc[i];
			dbproc_status[i]=2;
			proc_id=i;
			break;
		}
	}
	if (i==MAXPROCS)//没有空闲的db process
		ErrCheck(ERR_NONE_FREE_DBPROCESS,NULL);
	this->login=pDBSession.login;
	InitTrans();

}

DBLibrary::~DBLibrary()
{
	if(pTransactionDispenser)
   		pTransactionDispenser->Release();
	COLINFO *p,*q;
	p=q=NULL;
	if(COLUMN!=NULL) q=COLUMN;
	while(q)
	{
		COLUMN=COLUMN->next;
		p=COLUMN;
		delete q;
		q=p;
	}
	if(proc_id>=0)
		dbproc_status[proc_id]=1;

}

void DBLibrary::ErrCheck(int code=ERR_DBSYS,char *str=NULL)
{
	char tmp[100];
	memset(tmp,0,100);
	SetErrCode(code);
	switch(code)
	{
	case ERR_NO_FIND_COL:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_BCP_BIND_COL:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_COLTYPE_NOT_MATCHING:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
    case ERR_MAX_SQLSTR:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_BIND_DATABASE_FAIL:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_NO_FIND_COMPUTEID:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_NO_FIND_COMPUTECOLS:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_RESULTS_NOROWS:
		if(str!=NULL)
			sprintf(tmp,ERR_MSG[-code-100],str);
		else strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
		break;
	case ERR_DBSYS:
		break;
	default:
		strcpy(tmp,ERR_MSG[-code-100]);
		SetErrMsg(tmp);
	}
	if (GetAutoThrow()) 
		throw (*((DBErr *)this));
		//throw(*((WOCIError *)this));
}

int DBLibrary::WriteLog(bool ErrLog,const char *format,...)
{
	va_list vlist;
	va_start(vlist,format);
	FILE *lgfp=NULL;
	if (ErrLog)
		lgfp=fopen(ErrLogFile,"a+t");
	else
		lgfp=fopen(LogFileName,"a+t");
	if (lgfp==NULL) 
		return ErrLog ? -1 : -2;
	int rt;
	CTime curtime=CTime::GetCurrentTime();
	char tmptime[15];
	sprintf(tmptime,"%s",curtime.Format("%Y-%m-%d %H:%M:%S"));
	fprintf(lgfp,"[%s] ",tmptime);
	if (_output_to_console)
		rt=vprintf(format,vlist);
	
	rt=vfprintf(lgfp,format,vlist);
	int fmtlen=strlen(format);
	if(fmtlen > 1 && format[fmtlen - 1] !='\n')
	{
		if(_output_to_console)
			printf("\n");
		fprintf(lgfp,"\n");
	}
	va_end(vlist);
	fclose(lgfp);
	return rt;
}
/*
void DBLibrary::WriteSQLLog()
{
	WriteLog(false,"severity:%d %s, DBErrCode:%d, DBErrStr:%s",
		SYSERR.serverity,svrty[SYSERR.serverity],SYSERR.dberr,SYSERR.dberrstr);
	if(SYSERR.oserr != DBNOERR)
		WriteLog(true,"severity:%d %s,OSErrCode:%d, OSErrStr:%s",
			SYSERR.serverity,svrty[SYSERR.serverity],SYSERR.oserr,SYSERR.oserrstr);

}*/
int DBLibrary::SetDataBase(char *DBName)
{
 
	if(dbuse(dbproc,DBName)==FAIL)		 
		ErrCheck(ERR_BIND_DATABASE_FAIL,DBName);
	return 1;

}
int DBLibrary::Open(const char *format,...)
{
	EOFTAG=false;
	INIT_TAG=FALSE;
	dbcancel(dbproc);
	char strSQL[STRSQLMAX];
	int sql_len=0;
	va_list vlist;
	va_start(vlist,format);
	sql_len=vsprintf(strSQL,format,vlist);
	va_end(vlist);
	if (sql_len>=STRSQLMAX - 1)
	{
		char len[5];
		sprintf(len,"%d",STRSQLMAX);
		ErrCheck(ERR_MAX_SQLSTR,len);		
	}
	WriteLog(false,strSQL);

	if(dbcmd(dbproc,strSQL)==FAIL)
		ErrCheck(ERR_SQL_CMD);
	
//	if (!asynchronism) //如果不是异步执行
//	try
//	{
	if (dbsqlexec(dbproc)==FAIL) ErrCheck();	

	if (dbresults(dbproc)== FAIL)
		ErrCheck(ERR_SQL_RESULTS);
	if(dbresults(dbproc)==NO_MORE_RESULTS)
	{
		EOFTAG=true;
		return ERR_RESULTS_NOROWS;
	}
		//ErrCheck(ERR_RESULTS_NOROWS,strSQL);
	COLInit();
	return 1;
		
}

int DBLibrary::InitRead()
{
		 
	if(dbresults(dbproc) !=NO_MORE_RESULTS )//&& !INIT_TAG)
	{
		INIT_TAG=true;
		dbnextrow(dbproc);
		return 1;
	}
	return -1;		

}
int DBLibrary::Next()
{
	RETCODE row_code; 
	if ( !INIT_TAG ) 
		ErrCheck(ERR_NO_INIT_BUFF);
	if(dbresults(dbproc) !=NO_MORE_RESULTS)
	{
		row_code=dbnextrow(dbproc);
		switch(row_code)
		{	
		case NO_MORE_ROWS://没有结果行可读
			INIT_TAG=false;
			return EOFTAG=true;
			break;
		case REG_ROW://常规列
			return REG_ROW;
			break;
		default:
			if(row_code>0)
				return COMPUTE_COLS;
		}
	}

	return NO_MORE_RESULTS;
}

int DBLibrary::COLInit()
{
	
	int cols=dbnumcols(dbproc);
	if(cols<1)
		ErrCheck(ERR_RESULTS_NOCOLS,"COLInit->dbnumcols()");
	COLINFO *p,*q;
	int i=0;
	p=q=NULL;
	if(COLUMN!=NULL) q=COLUMN;
	while(q)
	{
		COLUMN=COLUMN->next;
		p=COLUMN;
		delete q;
		q=p;
	}
	COLUMN=NULL;
	
	while(++i<=cols)
	{
		p=new COLINFO;
		sprintf(p->name,"%s",strupr((char*)dbcolname(dbproc,i)));
		p->index=i;
		p->type=dbcoltype(dbproc,i);
		p->len=dbdatlen(dbproc,i);
		p->next=NULL;
	    if(COLUMN==NULL)
			COLUMN=q=p;
		else
		{
			q->next=p;
			q=q->next;
		}
	}
	int tmp=dbresults(dbproc);
	if(tmp==NO_MORE_RESULTS)
	{
		INIT_TAG=FALSE;
		EOFTAG=TRUE;
		return EOFTAG;
	}
	if(tmp !=NO_MORE_RESULTS && !INIT_TAG)
	{
		INIT_TAG=true;
		dbnextrow(dbproc);
		return EOFTAG;
	}
	return 1;
}
int DBLibrary::GetColID(char *colName)
{
	char curcol[COLEN];
	sprintf((char *)curcol,"%s",colName);
	for(COL=COLUMN;COL;COL=COL->next)
		if(strcmp(strupr(curcol),COL->name)==0)
			break;
	if(COL) return 1;
	return ERR_NO_FIND_COL;
}
int DBLibrary::GetComputeValue(int computeID,int columnID,
								long *pcValue)
{
	char tmp[4];
	memset(tmp,0,4);
	sprintf(tmp,"%d",columnID);
	int cptID=dbnumcompute(dbproc);
	if ( cptID != computeID)  
		ErrCheck(ERR_NO_FIND_COMPUTEID,tmp);
	int cptCols=dbnumalts(dbproc,cptID);
	if (cptCols<columnID || cptCols<1 || columnID<1) 
		ErrCheck(ERR_NO_FIND_COMPUTECOLS,tmp);
	
	switch(dbalttype(dbproc,computeID,columnID))
	{
	case SQLINT1:
	case SQLINT2:
	case SQLINT4:
	case SQLINTN:
		if(dbconvert(dbproc,SQLINT4,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLINT4,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
	    return 1;
		break;
	default:
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,"compute field");
	}
	return ERR_UNKNOW;

}

int DBLibrary::GetComputeValue(int computeID,int columnID,
								double *pcValue)
{
	char tmp[4];
	memset(tmp,0,4);
	sprintf(tmp,"%d",columnID);
	int cptID=dbnumcompute(dbproc);//取COMPUTE子句标号
	
	if ( cptID != computeID)  
		ErrCheck(ERR_NO_FIND_COMPUTEID,tmp);
	int cptCols=dbnumalts(dbproc,cptID);
	if (cptCols<columnID || cptCols<1 || columnID<1) 
		ErrCheck(ERR_NO_FIND_COMPUTECOLS,tmp);
	
	switch(dbalttype(dbproc,computeID,columnID))
	{
	case SQLFLT4:
	    if(dbconvert(dbproc,SQLFLT4,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLFLTN:
	    if(dbconvert(dbproc,SQLFLTN,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLFLT8:
	    if(dbconvert(dbproc,SQLFLT8,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLDECIMAL:
	    if(dbconvert(dbproc,SQLDECIMAL,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLDECIMAL,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLNUMERIC:
	    if(dbconvert(dbproc,SQLNUMERIC,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLNUMERIC,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLMONEY4:
	    if(dbconvert(dbproc,SQLMONEY4,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLMONEY:
	    if(dbconvert(dbproc,SQLMONEY,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	case SQLMONEYN:
	    if(dbconvert(dbproc,SQLMONEYN,dbadata(dbproc,computeID,columnID),
			(DBINT)-1,SQLFLT8,(LPBYTE)pcValue,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
			return 1;
		break;
	default:
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,tmp);
	}
	return ERR_UNKNOW;
}
long DBLibrary::GetValue(char *colName)
{
	long *lv=0;
	unsigned char bit[2];//tinyint byte(1),bit
	char smint[3];//smallint byte(2),多加1byte存放符号
	memset(bit,0,2);
	memset(smint,0,3);
	int id=GetColID(colName);
	if (id==ERR_NO_FIND_COL) ErrCheck(ERR_NO_FIND_COL,colName);
	switch(COL->type)
	{
	case SQLINT1:
		if(dbconvert(dbproc,SQLINT1,dbdata(dbproc,COL->index),
			(DBINT)-1,SQLCHAR,(LPBYTE)bit,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		return atol((char *)bit);
	case SQLINT2:
		if(dbconvert(dbproc,SQLINT2,dbdata(dbproc,COL->index),
			(DBINT)-1,SQLCHAR,(LPBYTE)smint,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		return atol((char *)smint);
	case SQLINT4:
	case SQLINTN:
		lv=(DBINT*)(dbdata(dbproc,COL->index));
		return *lv;
	case SQLBIT:
		if(dbconvert(dbproc,SQLBIT,dbdata(dbproc,COL->index),
			(DBINT)-1,SQLCHAR,(LPBYTE)bit,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		return atol((char *)bit);
	default:
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
	}
	return 1;
}

int DBLibrary::GetValue(char *colName,double *pdresult)
{
	int id=GetColID(colName);
	if (id==ERR_NO_FIND_COL) 
		ErrCheck(ERR_NO_FIND_COL,colName);
	if(dbresults(dbproc) !=NO_MORE_RESULTS)
	{
	
		switch(COL->type)
		{
		case SQLFLT4:
			if(dbconvert(dbproc,SQLFLT4,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLFLT4,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLFLTN:
			if(dbconvert(dbproc,SQLFLTN,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLFLTN,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLFLT8:
			if(dbconvert(dbproc,SQLFLT8,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLFLT8,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLDECIMAL:
			if(dbconvert(dbproc,SQLDECIMAL,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLDECIMAL,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLNUMERIC:
			if(dbconvert(dbproc,SQLNUMERIC,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLNUMERIC,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLMONEY4:
			if(dbconvert(dbproc,SQLMONEY4,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLFLT8,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		case SQLMONEY:
			if(dbconvert(dbproc,SQLMONEY,dbdata(dbproc,COL->index),
				(DBINT)-1,SQLFLT8,(LPBYTE)pdresult,(DBINT)-1)==FAIL)
				ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
			break;
		default:
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		}
	}
	return 1;
}
int DBLibrary::GetValue(char *colName,char *cpresult) //char,text,varchar,money,smallmoney
{
	
	int id=0;
	id=GetColID(colName);
	if (id==ERR_NO_FIND_COL) 
		ErrCheck(ERR_NO_FIND_COL,colName);
	switch(COL->type)
	{
	case SQLCHAR:
	case SQLVARCHAR:
	case SQLTEXT:
		memset(cpresult,0,strlen(cpresult));
		strncpy(cpresult,(char *)dbdata(dbproc,COL->index),dbdatlen(dbproc,COL->index));
		//return dbbind(dbproc,COL->index,NTBSTRINGBIND,(DBINT)0,(LPBYTE)cpresult);
		break;
	default:
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
	}

	return 1;
}
int DBLibrary::GetDate(char *colName,char *strdate)
{
	int id=GetColID(colName);
	if (id==ERR_NO_FIND_COL) 
		ErrCheck(ERR_NO_FIND_COL,colName);
	switch(COL->type)
	{
	case SQLDATETIM4:
	case SQLDATETIME:
		DBDATEREC dc;
		int rt;
		rt=dbdatecrack(dbproc,&dc,(DBDATETIME *)dbdata(dbproc,COL->index));
		if (rt==1)
		{
			char tmp_date[20];
			/*	sprintf(tmp_date,"%04d-%02d-%02d %02d:%02d:%02d",
					dc->year,dc->month,dc->day,dc->hour,dc->minute,dc->second);
					*/
			sprintf(tmp_date,"%04d-%02d-%02d %02d:%02d:%02d",
				dc.year,dc.month,dc.day,dc.hour,dc.minute,dc.second);
			//memset(strdate,' ',strlen(tmp_date));
			//	(strdate,tmp_date,strlen(tmp_date));*/
			sprintf(strdate,"%s",tmp_date);
			return 1;
		}
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
	default:
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
	}
   return 1;
}
int DBLibrary::InitBCP(char *SourceTableName,
					   char *OutFileName,
					   char *LogFileName,
					   const int BCPT)
{
	return bcp_init(dbproc,(LPCSTR)SourceTableName,(LPCSTR)OutFileName,(LPCSTR)LogFileName,BCPT);
}
long DBLibrary::BatchCopyToFile(char *TableName,
							   char *FileName,
							   int col[],
							   int cols,
							   char *term,
							   int termlen,
							   int StartRow
							   //int BatchNum
							   )
{
/*	if(InitBCP(TableName,FileName,"outLogFile.txt",DB_OUT)==FAIL)
		return ERR_BATCH_COPY_INIT;
	if(bcp_control(dbproc,BCPFIRST,(DBINT)StartRow)==FAIL)
		return ERR_BATCH_COPY_CONTROL;

	if (bcp_columns(dbproc,cols)==FAIL)
		return ERR_BATCH_COPY_COLSET;
	for (int i=1;i<=cols;i++)
	{
		if (i==cols)
		{
			if (bcp_colfmt(dbproc,i,SQLCHAR,0,-1,(LPCBYTE)"\r\n",2,col[i-1])==FAIL) 
				return ERR_BATCH_COPY_FORMAT;	
		}
		else
			if (bcp_colfmt(dbproc,i,SQLCHAR,0,-1,(LPCBYTE)term,termlen,col[i-1])==FAIL) 
				return ERR_BATCH_COPY_FORMAT;
	}
	long rows=0;
	if(bcp_exec(dbproc,&rows)==FAIL)
		if (rows>0)
			return rows;
		else
			return ERR_BATCH_COPY_EXEC;
	return rows;
	*/
	
	if(bcp_init(dbproc,"test_db","test_db.txt",(LPCSTR)NULL,DB_OUT)==FAIL)
		throw "bcp_init error";
	if(bcp_control(dbproc,BCPFIRST,(DBINT)1)==FAIL)
		throw "bcp_control error";
	if(bcp_columns(dbproc,3)==FAIL)
		throw "bcp_columns error";
	
	if(bcp_colfmt(dbproc,1,SQLCHAR,0,(DBINT)42,(LPCBYTE)"\t",1,1)==FAIL)
		throw "bcp_colfmt error (col:1)";

	if(bcp_colfmt(dbproc,2,SQLCHAR,0,(DBINT)42,(LPCBYTE)"\r\n",2,2)==FAIL)
		throw "bcp_colfmt error (col:2)";
/*	if(bcp_colfmt(dbproc,3,SQLCHAR,0,-1,(LPCBYTE)",",1,3)==FAIL)
		throw "bcp_colfmt error (col:1)";

	if(bcp_colfmt(dbproc,4,SQLCHAR,0,-1,(LPCBYTE)",",1,4)==FAIL)
		throw "bcp_colfmt error (col:2)";
	if(bcp_colfmt(dbproc,5,SQLCHAR,0,-1,(LPCBYTE)",",1,5)==FAIL)
		throw "bcp_colfmt error (col:1)";

	if(bcp_colfmt(dbproc,6,SQLCHAR,0,-1,(LPCBYTE)",",1,6)==FAIL)
		throw "bcp_colfmt error (col:2)";
	if(bcp_colfmt(dbproc,7,SQLCHAR,0,-1,(LPCBYTE)",",1,7)==FAIL)
		throw "bcp_colfmt error (col:1)";

	if(bcp_colfmt(dbproc,8,SQLCHAR,0,-1,(LPCBYTE)",",1,8)==FAIL)
		throw "bcp_colfmt error (col:2)";
	if(bcp_colfmt(dbproc,9,SQLCHAR,0,-1,(LPCBYTE)",",1,9)==FAIL)
		throw "bcp_colfmt error (col:1)";

	if(bcp_colfmt(dbproc,10,SQLCHAR,0,-1,(LPCBYTE)"\r\n",2,10)==FAIL)
		throw "bcp_colfmt error (col:2)";
	*/	
	long rows=0;
    if(bcp_exec(dbproc,&rows)==FAIL)
		throw "bcp_exec error";
   return rows;
   
}

int DBLibrary::ExecSQL(const char *format,...)
{
	dbcancel(dbproc);
	char strSQL[STRSQLMAX];
	int sql_len=0;
	va_list vlist;
	va_start(vlist,format);
	sql_len=vsprintf(strSQL+1,format,vlist);
	strSQL[0]=' ';
	va_end(vlist);
	if (sql_len>=STRSQLMAX - 1)
	{
		char len[5];
		sprintf(len,"%d",STRSQLMAX);
		ErrCheck(ERR_MAX_SQLSTR,len);		
	}
	if (dbcmd(dbproc,strSQL)!=SUCCEED)
		ErrCheck(ERR_SQL_CMD);
//	if (!asynchronism) //如果不是异步执行

	if(dbsqlexec(dbproc)==FAIL) ErrCheck();
	if(dbresults(dbproc)==FAIL) ErrCheck(ERR_SQL_RESULTS);
	//else {}
	return 1;
}
int DBLibrary::BeginTrans()
{
	dbcancel(dbproc);
	HRESULT curHr=0;
	curHr = pTransactionDispenser->BeginTransaction( 
				NULL,							//	/* [in]  */ IUnknown __RPC_FAR *punkOuter,
				ISOLATIONLEVEL_ISOLATED,		//	/* [in]  */ ISOLEVEL isoLevel,
				ISOFLAG_RETAIN_DONTCARE,		// 	/* [in]  */ ULONG isoFlags,
				NULL,							//	/* [in]  */	ITransactionOptions *pOptions 
				&pTransaction					//	/* [out] */ ITransaction **ppTransaction
				) ;
			
		if (FAILED (curHr))
			ErrCheck(ERR_TRANS_BEGIN);
	
	
		RETCODE rc = 0;
		rc = dbenlisttrans (dbproc, pTransaction);
				
		if (FAIL == rc) 
			ErrCheck(ERR_TRANS_LIST);

		ISTRANS=true;
		return 1;



/*
	if(dbcmd(dbproc," BEGIN TRANSACTION ")==SUCCEED)
	{
		if(dbcmd(dbproc," SAVE TRANSACTION dbtransaction ")==SUCCEED)
			return 1;
		else return -1;
	}
	*/
	
}
int DBLibrary::CommitTrans()
{
	HRESULT curHr=0;
	curHr = pTransaction->Commit(0,0,0);
	if (FAILED(curHr))
	{
		curHr = pTransaction->Release();
		if (FAILED(curHr))
			ErrCheck(ERR_TRANS_COMMIT_RELEASE);
		ErrCheck(ERR_TRANS_COMMIT);
	}

		// At end of each transaction, pTransaction-Release() must be called.
	//	pTransactionDispenser->Release();
	/*	if (dbenlisttrans (dbproc, NULL)==FAIL) 
		{
			sprintf(msg,"%s","提交成功后释放事务失败.");
			SetMsg(msg);
			throw GetErr();
		}
	*/	
		curHr = pTransaction->Release();
		if (FAILED(curHr))
            ErrCheck(ERR_TRANS_RELEASE);

		if (dbenlisttrans (dbproc, NULL)==FAIL) 
			ErrCheck(ERR_TRANS_FREE);
	    ISTRANS=false;
		return 1;		
}
int DBLibrary::RollbackTrans()
{
	if ( !ISTRANS ) return 0;
	HRESULT curHr=0;
	
	curHr=pTransaction->Abort(NULL,FALSE,FALSE);
	if (FAILED(curHr))
       ErrCheck(ERR_TRANS_ABORT);    
	if (dbenlisttrans(dbproc,NULL)==FAIL) 
       ErrCheck(ERR_TRANS_ROLLBACK_RELEASE);
	pTransaction->Release();

	ISTRANS=FALSE;
	return 1;
	//pTransactionDispenser->Release();
}
int DBLibrary::InitTrans()
{
	hr = DtcGetTransactionManager(NULL, 							// LPTSTR	pszHost,
									NULL, 							// LPTSTR	pszTmName,
									IID_ITransactionDispenser,		// /* in */ REFIID	rid,
								    0,								// /* in */ DWORD	dwReserved1,
								    0, 								// /* in */ WORD	wcbReserved2,
								    0,								// /* in */ void	FAR * pvReserved2,
									(void **)&pTransactionDispenser // /*out */ void**	ppvObject
									) ;
	if (FAILED (hr)) 
		ErrCheck(ERR_DTC_MANAGER);
 	
	return 1;

}

int DBLibrary::BCPInitTable(char *tableName)
{
	dbcancel(dbproc);
	if(dbfcmd(dbproc,"select top 0 * from %s ",tableName)==FAIL) 
		ErrCheck(ERR_SQL_CMD);
	if(dbsqlexec(dbproc)==FAIL) 
		ErrCheck();
	if(dbresults(dbproc)==FAIL) 
		ErrCheck(ERR_SQL_RESULTS);
	int cols=dbnumcols(dbproc);
	if(cols<1) {
		char cur[100];
		sprintf(cur,"select top 0 * from %s ",tableName);
		ErrCheck(ERR_RESULTS_NOCOLS,cur);
	}
	
	COLINFO *p,*q;
	int i=0;
	p=q=NULL;
	if(COLUMN!=NULL) q=COLUMN;
	while(q)
	{
		COLUMN=COLUMN->next;
		p=COLUMN;
		delete q;
		q=p;
	}
	COLUMN=NULL;
	
	while(++i<=cols)
	{
		p=new COLINFO;
		sprintf(p->name,"%s",strupr((char*)dbcolname(dbproc,i)));
		p->index=i;
		p->type=dbcoltype(dbproc,i);
		p->len=dbdatlen(dbproc,i);
		p->next=NULL;
	    if(COLUMN==NULL)
			COLUMN=q=p;
		else
		{
			q->next=p;
			q=q->next;
		}
	}


	//int i=0;
	/*int len=0;
	char *str1;
	while(++i<=cols)
	{
		str1=(char *)dbcolname(dbproc,i);
		len=strlen(str1);
		ColumnName[i-1]=new char[len];
		sprintf(ColumnName[i-1],"%s",strupr(str1));
		*(ColumnType+(i-1))=dbcoltype(dbproc,i);
	}
	*/
	if(dbcancel(dbproc)==FAIL)
		ErrCheck(ERR_CANCEL_RESULTS);
	if(bcp_init(dbproc,tableName,(LPCSTR)NULL,(LPCSTR)NULL,DB_IN)==FAIL)
		ErrCheck(ERR_BATCH_COPY_INIT);
	return 1;
}
int DBLibrary::BCPInteger(char *colName,long *lpvalue)
{
	int id=0;
	id=GetColID(colName);
	if(id==ERR_NO_FIND_COL)
		ErrCheck(ERR_NO_FIND_COL,colName);
	if(bcp_bind(dbproc,(LPCBYTE)lpvalue,0,(DBINT)-1,(LPCBYTE)NULL,0,COL->type,COL->index)==FAIL)
		ErrCheck(ERR_BCP_BIND_COL,colName);
	return 1;
}
int DBLibrary::BCPDouble(char *colName,double *dpvalue)
{
	int id=0;
	id=GetColID(colName);
	if(id==ERR_NO_FIND_COL)
		ErrCheck(ERR_NO_FIND_COL,colName);
	//switch (*(ColumnType+(id-1)))
	switch(COL->type)
	{
	case SQLMONEY4:
		static DBMONEY4 sm;
		if(dbconvert(NULL,SQLFLT8,(LPCBYTE)dpvalue,(DBINT)-1,SQLMONEY4,(LPBYTE)&sm,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		if(bcp_bind(dbproc,(LPCBYTE)&sm,0,(DBINT)-1,(LPCBYTE)NULL,0,0,COL->index)==FAIL)
			ErrCheck(ERR_BCP_BIND_COL,colName);
		break;
	case SQLMONEY:
		static DBMONEY m;
		if(dbconvert(NULL,SQLFLT8,(LPCBYTE)dpvalue,(DBINT)-1,SQLMONEY,(LPBYTE)&m,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		if(bcp_bind(dbproc,(LPCBYTE)&m,0,(DBINT)-1,(LPCBYTE)NULL,0,0,COL->index)==FAIL)
			ErrCheck(ERR_BCP_BIND_COL,colName);
		break;
	default:
	if(bcp_bind(dbproc,(LPCBYTE)dpvalue,0,(DBINT)-1,(LPCBYTE)NULL,0,COL->type,COL->index)==FAIL)
		ErrCheck(ERR_BCP_BIND_COL,colName);
	}	
	return 1;

}

int DBLibrary::BCPString(char *colName,char *cpvalue)//,char *term="\0",int termlen=1)
{
	int id=0;
	id=GetColID(colName);
	if(id==ERR_NO_FIND_COL)
		ErrCheck(ERR_NO_FIND_COL,colName);
	switch(COL->type)
	{
	case SQLDATETIM4:
		static DBDATETIM4 sdt;

		if(dbconvert(NULL,SQLCHAR,(LPCBYTE)cpvalue,(DBINT)-1,SQLDATETIM4,(LPBYTE)&sdt,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
		if(bcp_bind(dbproc,(LPCBYTE)&sdt,0,(DBINT)-1,(LPCBYTE)NULL,0,0,COL->index)==FAIL)
			ErrCheck(ERR_BCP_BIND_COL,colName);
		break;
	case SQLDATETIME:
		static DBDATETIME d;	
		
        if(dbconvert(NULL,SQLCHAR,(LPCBYTE)cpvalue,(DBINT)-1,SQLDATETIME,(LPBYTE)&d,(DBINT)-1)==FAIL)
			ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
	    if(bcp_bind(dbproc,(LPCBYTE)&d,0,(DBINT)-1,(LPCBYTE)NULL,0,0,COL->index)==FAIL)
			ErrCheck(ERR_BCP_BIND_COL,colName);
		break;
	default:
		//static char *cur=cpvalue;
		if(bcp_bind(dbproc,(LPCBYTE)cpvalue,0,(DBINT)strlen(cpvalue),(LPCBYTE)NULL,0,COL->type,COL->index)==FAIL)//(LPCBYTE)term,termlen,*(ColumnType+(id-1)),id)==FAIL)
			ErrCheck(ERR_BCP_BIND_COL,colName);
			
	}	
	
	return 1;
	

}
int DBLibrary::BCPSaveDone()
{
	if(bcp_sendrow(dbproc)==FAIL)
		ErrCheck(ERR_BCP_SEND_ROW);
	if(bcp_done(dbproc)==FAIL)
		ErrCheck(ERR_BCP_SAVE_DONE);
	return 1;
}
int DBLibrary::BCPSaveBatch()
{
	if(bcp_sendrow(dbproc)==FAIL)
		ErrCheck(ERR_BCP_SEND_ROW);
	if(bcp_batch(dbproc)==FAIL)
		ErrCheck(ERR_BCP_SAVE_BATCH);
	return 1;
}
int DBLibrary::BCPBinary(char *colName,char *buf)
{
	int id=0;
	int len=strlen(buf);
//	DBBINARY *curB=new DBBINARY[len+1];
//	memset(curB,0,len+1);
//	id=bcp_sendrow(dbproc);
	id=GetColID(colName);
	if(id==ERR_NO_FIND_COL)
		ErrCheck(ERR_NO_FIND_COL,colName);
	//switch(*(ColumnType+(id-1)))
	switch(COL->type)
	{
	case SQLBINARY:
		/*
		if(dbconvert(NULL,SQLCHAR,(LPCBYTE)buf,(DBINT)len,SQLBINARY,(LPBYTE)curB,(DBINT)len)==FAIL)
			return ERR_COLTYPE_NOT_MATCHING;
		*/	
		if(bcp_bind(dbproc,(LPCBYTE)buf,0,(DBINT)len,(LPCBYTE)NULL,0,SQLBINARY,COL->index)==FAIL)
			ErrCheck(ERR_BCP_BIND_COL,colName);
		/*	
		if(bcp_bind(dbproc,(LPCBYTE)NULL,0,(DBINT)len,(LPCBYTE)NULL,0,SQLBINARY,id)==FAIL)
			return ERR_BCP_BIND_COL;
		if(bcp_moretext(dbproc,(DBINT)len,(LPCBYTE)buf)==FAIL)
			return ERR_BCP_MORETEXT;
			*/
		break;
	case SQLVARBINARY:
		/*
		if(dbconvert(NULL,SQLCHAR,(LPCBYTE)buf,(DBINT)-1,SQLVARBINARY,(LPBYTE)curB,(DBINT)-1)==FAIL)
			return ERR_COLTYPE_NOT_MATCHING;
			*/
		if(bcp_bind(dbproc,(LPCBYTE)buf,0,(DBINT)len,(LPCBYTE)NULL,0,SQLVARBINARY,COL->index)==FAIL)
			ErrCheck(ERR_BCP_BIND_COL,colName);
		/*
		if(bcp_bind(dbproc,(LPCBYTE)NULL,0,(DBINT)len,(LPCBYTE)NULL,0,SQLVARBINARY,id)==FAIL)
			return ERR_BCP_BIND_COL;
		if(bcp_moretext(dbproc,(DBINT)len,(LPCBYTE)buf)==FAIL)
			return ERR_BCP_MORETEXT;
			*/
		break;

	case SQLIMAGE:	
		/*
		if(dbconvert(NULL,SQLCHAR,(LPCBYTE)buf,(DBINT)-1,SQLIMAGE,(LPBYTE)curB,(DBINT)-1)==FAIL)
			return ERR_COLTYPE_NOT_MATCHING;
			*/
		if(bcp_bind(dbproc,(LPCBYTE)buf,0,(DBINT)len,(LPCBYTE)NULL,0,SQLBINARY,COL->index)==FAIL)
			ErrCheck(ERR_BCP_BIND_COL,colName);
	 /*
		if(bcp_bind(dbproc,(LPCBYTE)NULL,0,(DBINT)len,(LPCBYTE)NULL,0,SQLIMAGE,id)==FAIL)
			return ERR_BCP_BIND_COL;
		if(bcp_moretext(dbproc,(DBINT)len,(LPCBYTE)buf)==FAIL)
			return ERR_BCP_MORETEXT;
			*/
		break;

	default:
		ErrCheck(ERR_COLTYPE_NOT_MATCHING,colName);
	}	
	
	return 1;
	

}

int DBLibrary::ProcInit(char *procName)
{
	if(dbrpcinit(dbproc,procName,(DBSMALLINT)0)==FAIL)
		ErrCheck(ERR_PROC_INIT);
	return 1;
}
int DBLibrary::ProcParam(char *param,
						 bool isReturn,
						 int paramType,
						 long maxlen,
						 long datalen,
						 LPCBYTE paramValue)
{
	int statu=0;
	if(isReturn) statu=DBRPCRETURN;
	if(dbrpcparam(dbproc,param,statu,paramType,(DBINT)maxlen,(DBINT)datalen,(LPCBYTE)paramValue)==FAIL)
		ErrCheck(ERR_PROC_PARAM);
	return 1;
}
int DBLibrary::ProcExec()
{
	EOFTAG=false;
	INIT_TAG=FALSE;
//	dbcancel(dbproc);

	if(dbrpcexec(dbproc)==FAIL)
		ErrCheck(ERR_PROC_SEND);
	if(dbsqlok(dbproc)==FAIL)
		ErrCheck(ERR_PROC_LOCK);
	/*
	if(dbresults(dbproc)==FAIL)
		return ERR_PROC_RESULT;
		*/
    COLInit();
	//dbprrow(dbproc);
	return 1;
}

void DBLibrary::init()
{
	EOFTAG=false;
	INIT_TAG=false;
	ISTRANS=false;
	hr=S_OK;
	pTransaction=NULL;
	pTransactionDispenser=NULL;
	COLUMN=NULL;
	COL=NULL;
	COMPUTE_COLS=100;
	ParamType.SQL_tinyint		=	SQLINT1;
	ParamType.SQL_smallint		=	SQLINT2;
	ParamType.SQL_int			=	SQLINT4;
	ParamType.SQL_real			=	SQLFLT4;
	ParamType.SQL_float			=	SQLFLT8;
	ParamType.SQL_decimal		=	SQLDECIMAL;
	ParamType.SQL_numeric		=	SQLNUMERIC;
	ParamType.SQL_smallmoney	=	SQLMONEY4;
	ParamType.SQL_money			=	SQLMONEY;
	ParamType.SQL_char			=	SQLCHAR;
	ParamType.SQL_varchar		=	SQLVARCHAR;
	ParamType.SQL_smalldatetime	=	SQLDATETIM4;
	ParamType.SQL_datetime		=	SQLDATETIME;
}